import api from '../../api/index';
import common from '../../common/index';

interface IUserInfo {
  nickName?: string;
  avatarUrl?: string;
  [key: string]: any;
}

interface IFeedItem {
  id: string;
  uid: string;
  avatar: string;
  username: string;
  image: string;
  title: string;
  ai_title?: string;
  likes: string;
  comments: string;
  height?: number;
  liked?: boolean;
  collected?: boolean;
  collection?: number;
}

const app = getApp()

Page({
  data: {
    uid: '',
    statusBarHeight: app.globalData.statusBarHeight,
    navBarHeight: app.globalData.navBarHeight,
    menuWidth: app.globalData.menuWidth,
    userInitial: 'A',
    userInfo: null as IUserInfo | null,
    showToast: false,
    loading: false,
    feedList: [] as IFeedItem[],
    leftColumnData: [] as IFeedItem[],
    rightColumnData: [] as IFeedItem[],
    pcenterPageShow: false,
    searchText: '', // 搜索文本
    isSearchMode: false, // 是否处于搜索模式
    // 分页相关状态
    pageIndex: 1,        // 当前页码，从1开始
    pageSize: 20,        // 每页数据量
    hasMore: true,       // 是否还有更多数据
    isLoadingMore: false, // 是否正在加载更多
    collectedIds: new Set<string>(), // 新增：用于存储已收藏的灵感ID
    // 标签管理相关
    showTagActionSheet: false, // 标签操作表单显示状态
    availableTags: [] as any[], // 可用标签列表（对象数组）
    selectedTags: [] as string[], // 选中的标签列表
    newTagName: '', // 新标签名称
    showTagModal: false, // 标签管理弹窗显示状态
    currentCollectingItem: null as any // 当前正在收藏的项目
  },

  onLoad() {
    // 获取用户uid，参考home-chat.ts的方式
    const user = common.getAppUserInfo();
    let uid = user.uid;
    
    // 如果用户未登录，使用默认uid或空字符串，让未登录用户也能看到推荐内容
    if (!uid) {
      uid = 'guest'; // 使用默认的游客uid，或者使用空字符串
      console.log('用户未登录，使用默认uid:', uid);
    }
    
    this.setData({
      uid: uid,
      userInfo: user // 设置用户信息，包括头像
    });
    
    // 如果用户已登录，获取最新的用户信息（包括头像）
    if (uid && uid !== 'guest') {
      this.fetchUserInfo();
    }
    
    // 无论是否登录，都调用灵感推荐接口获取数据
    this.fetchInspirationData();
  },

  onShow() {
    // 页面显示时检查用户登录状态
    this.checkUserLoginStatus();
    
    // 如果当前用户信息不完整，重新获取
    if (this.data.userInfo && !this.data.userInfo.icon && this.data.uid && this.data.uid !== 'guest') {
      this.fetchUserInfo();
    }
  },

  // 检查用户登录状态
  checkUserLoginStatus() {
    const user = common.getAppUserInfo();
    const currentUid = this.data.uid;
    const newUid = user.uid;
    
    // 如果用户登录状态发生变化
    if (newUid && newUid !== currentUid) {
      console.log('用户登录状态变化:', { 旧uid: currentUid, 新uid: newUid });
      this.setData({ 
        uid: newUid,
        userInfo: user // 同时更新用户信息
      });
      
      // 获取最新的用户信息（包括头像）
      this.fetchUserInfo();
      
      // 重新获取收藏状态和推荐数据
      this.refreshDataAfterLogin();
    } else if (!newUid && currentUid !== 'guest') {
      // 用户退出登录
      console.log('用户退出登录，切换到游客模式');
      this.setData({ 
        uid: 'guest',
        userInfo: null // 清空用户信息
      });
      
      // 清空收藏状态，重新获取推荐数据
      this.setData({ collectedIds: new Set<string>() });
      this.fetchInspirationData();
    }
  },

  // 登录后刷新数据
  async refreshDataAfterLogin() {
    try {
      console.log('=== 登录后刷新数据 ===');
      
      // 重新获取收藏状态
      const collectedIds = await this.fetchCollectionStatus();
      this.setData({ collectedIds });
      
      // 重新获取推荐数据（保持当前分页状态）
      await this.fetchInspirationData();
      
      console.log('登录后数据刷新完成');
    } catch (error) {
      console.error('登录后数据刷新失败:', error);
    }
  },

  getFirstLetter(nickname: string): string {
    if (!nickname || nickname.length === 0) {
      return 'A';
    }
    
    const firstChar = nickname.charAt(0).toUpperCase();
    if (/[\u4e00-\u9fa5]/.test(firstChar)) {
      return firstChar;
    }
    if (/[a-zA-Z]/.test(firstChar)) {
      return firstChar;
    }
    return 'A';
  },

  // 获取用户基本信息
  async fetchUserInfo() {
    try {
      // 获取用户uid
      const user = common.getAppUserInfo();
      const uid = user.uid || user.userId || '';
      
      if (!uid) {
        return;
      }
      
      const requestData = { uid };
      const res = await api.getUserInfo(requestData);
      
      if (res) {
                // 尝试从多个字段获取头像信息
                let iconField = (res as any).icon || (res as any).avatar || (res as any).avatarUrl || '';
        
        // 如果接口没有返回头像信息，尝试从本地存储获取
        if (!iconField) {
          const localUser = common.getLocalUser();
          const appUser = common.getAppUserInfo();
          iconField = localUser.icon || appUser.icon || '';
        }
        
        // 更新返回数据，确保包含头像信息
        const userInfoWithIcon = {
          ...res,
          icon: iconField
        };
        
        this.updateUserInfoDisplay(userInfoWithIcon);
      } else {
        wx.showToast({
          title: '获取用户信息失败',
          icon: 'error'
        });
      }
    } catch (error: any) {
      wx.showToast({
        title: '网络错误',
        icon: 'error'
      });
    }
  },

  // 统一更新用户信息显示
  updateUserInfoDisplay(userInfo: any) {
    if (!userInfo) return;
    
    // 处理头像URL，参考其他页面的实现
    if (userInfo.icon) {
      // 如果icon字段包含完整路径，需要处理
      if (userInfo.icon.startsWith('http')) {
        // 已经是完整URL，不需要处理
      } else {
        // 处理相对路径，确保icon字段正确设置
      }
    }
    
    // 确保用户信息包含所有必要字段，但保留已有的头像信息
    const currentUserInfo = this.data.userInfo || {};
    
    // 如果当前已有头像且新数据没有头像，保留当前头像
    // 如果当前已有头像且新数据也有头像，优先使用新数据（但确保URL一致性）
    let finalIcon = userInfo.icon || currentUserInfo.icon || '';
    
    // 如果新数据是相对路径，但当前数据是完整URL，保持当前数据
    if (userInfo.icon && !userInfo.icon.startsWith('http') && currentUserInfo.icon && currentUserInfo.icon.startsWith('http')) {
      finalIcon = currentUserInfo.icon;
    }
    
    const updatedUserInfo = {
      ...currentUserInfo,
      ...userInfo,
      // 使用处理后的头像URL
      icon: finalIcon
    };
    
    // 更新用户首字母
    const nickName = updatedUserInfo.nickName || updatedUserInfo.nickname || '';
    const userInitial = this.getFirstLetter(nickName);
    
    this.setData({
      userInfo: updatedUserInfo,
      userInitial: userInitial
    });
  },

  onInitialButtonClick(): void {
    // 直接跳转到profile页面，不需要先获取用户信息
    wx.navigateTo({
      url: '/pages/inspection/profile/profile'
    });
  },

  // 显示个人中心页面
  showPcenterPage() {
    this.setData({
      pcenterPageShow: true
    });
  },

  // 关闭个人中心页面
  closePcenterPage() {
    this.setData({
      pcenterPageShow: false
    });
  },

  // 获取灵感推荐数据
  async fetchInspirationData(isLoadMore: boolean = false): Promise<void> {
    try {
      if (isLoadMore) {
        this.setData({ isLoadingMore: true });
      } else {
        this.setData({ loading: true });
      }

        // 在获取灵感数据之前，先获取用户的收藏状态（仅登录用户）
        if (this.data.uid && this.data.uid !== 'guest') {
          console.log('=== 先获取用户收藏状态 ===');
          await this.fetchCollectionStatus();
        } else {
          console.log('用户未登录，跳过收藏状态获取');
        }
      
      // 修复分页逻辑：加载更多时使用当前页码+1，初始加载时使用页码1
      const currentPageIndex = isLoadMore ? this.data.pageIndex + 1 : 1;
      console.log('=== 调用灵感推荐接口 ===');
      console.log('请求参数:', {
        uid: this.data.uid,
        page_index: currentPageIndex,
        page_size: this.data.pageSize,
      });
      
      const res = await api.inspirationRecommend({
        uid: this.data.uid,
        page_index: currentPageIndex,
        page_size: this.data.pageSize,
      });
      
      console.log('灵感推荐数据:', res);
      
      if (res.data && res.data.length) {
        console.log('=== 处理API返回数据 ===');
        console.log('API返回的原始数据:', res.data);
        console.log('当前页码:', currentPageIndex, '每页大小:', this.data.pageSize);
        
        // 处理图片URL，参考home-chat.ts的处理方式
        res.data.forEach((item: any) => {
          item.image_url = 'https://www.aispire.info' + item.image_url.replace(/.*?(?=\/inspiration_images)/, '').replace(/.*?(?=\/private_knowledge)/, '');
          // 修复头像URL处理
          if (item.icon && !item.icon.startsWith('http')) {
            item.icon = 'https://www.aispire.info' + item.icon.replace(/.*?(?=\/user_portrait)/, '');
          }
        });
        
        console.log('处理图片URL后的数据:', res.data);
        
        // 转换API返回的数据格式为feedList格式，并应用收藏状态
        const newFeedList = this.transformApiDataWithCollectionStatus(res.data);
        
        console.log('转换后的新数据（包含收藏状态）:', newFeedList);
        
        if (isLoadMore) {
          // 加载更多：合并数据
          const allFeedList = [...this.data.feedList, ...newFeedList];
          const totalCount = allFeedList.length;
          
          // 计算是否还有更多数据：如果当前总数小于400条且本页返回了完整的一页数据，说明还有更多
          const hasMoreData = totalCount < 400 && newFeedList.length === this.data.pageSize;
          
          console.log('加载更多数据统计:', {
            原有数据量: this.data.feedList.length,
            新增数据量: newFeedList.length,
            总数据量: totalCount,
            是否还有更多: hasMoreData,
            目标总数: 400
          });
          
          // 修复：只有在成功加载数据后才更新页码
          this.setData({
            feedList: allFeedList,
            pageIndex: currentPageIndex, // 更新为当前请求的页码
            hasMore: hasMoreData
          });
        } else {
          // 初始加载：替换数据
          const totalCount = newFeedList.length;
          const hasMoreData = totalCount < 400 && newFeedList.length === this.data.pageSize;
          
          console.log('初始加载数据统计:', {
            数据量: totalCount,
            是否还有更多: hasMoreData,
            目标总数: 400
          });
          
          this.setData({
            feedList: newFeedList,
            pageIndex: 1, // 初始加载时重置为第1页
            hasMore: hasMoreData
          });
        }
        
        console.log('当前总数据量:', this.data.feedList.length);
        console.log('是否还有更多数据:', this.data.hasMore);
        console.log('当前页码:', this.data.pageIndex);
        
        this.distributeData();
        
        // 验证分页状态的一致性
        this.validatePaginationState();
      } else {
        if (isLoadMore) {
          // 加载更多时没有数据，说明已经到底了
          console.log('加载更多时没有返回数据，已到达数据末尾');
          this.setData({ 
            hasMore: false,
            // 修复：不改变当前页码，因为这次请求失败了
          });
          wx.showToast({
            title: '没有更多数据了',
            icon: 'none',
            duration: 1500
          });
        } else {
          console.log('没有获取到灵感推荐数据');
          this.setData({ 
            feedList: [],
            hasMore: false,
            pageIndex: 1
          });
          wx.showToast({
            title: '暂无推荐内容',
            icon: 'none',
            duration: 2000
          });
        }
      }
    } catch (error) {
      console.error('调用inspirationRecommend接口失败:', error);
      
      if (isLoadMore) {
        // 加载更多失败时，不重置页码，让用户重试
        console.log('加载更多失败，保持当前页码:', this.data.pageIndex);
      } else {
        // 初始加载失败时，重置状态
        this.setData({ 
          feedList: [],
          hasMore: false,
          pageIndex: 1
        });
      }
      
      wx.showToast({
        title: '网络错误，请重试',
        icon: 'error',
        duration: 2000
      });
    } finally {
      if (isLoadMore) {
        this.setData({ isLoadingMore: false });
      } else {
        this.setData({ loading: false });
      }
    }
  },

  // 验证分页状态的一致性
  validatePaginationState(): void {
    console.log('=== 验证分页状态 ===');
    console.log('当前分页状态:', {
      pageIndex: this.data.pageIndex,
      pageSize: this.data.pageSize,
      totalDataCount: this.data.feedList.length,
      hasMore: this.data.hasMore,
      expectedTotalPages: Math.ceil(this.data.feedList.length / this.data.pageSize)
    });
    
    // 验证页码的合理性
    if (this.data.pageIndex < 1) {
      console.warn('页码异常：pageIndex < 1，重置为1');
      this.setData({ pageIndex: 1 });
    }
    
    // 验证是否还有更多数据的逻辑
    const currentTotalCount = this.data.feedList.length;
    const maxExpectedCount = 400; // 最大预期数据量
    const hasMoreData = currentTotalCount < maxExpectedCount;
    
    if (this.data.hasMore !== hasMoreData) {
      console.warn('hasMore状态不一致，自动修正:', {
        当前状态: this.data.hasMore,
        计算状态: hasMoreData,
        当前总数: currentTotalCount,
        最大预期: maxExpectedCount
      });
      this.setData({ hasMore: hasMoreData });
    }
    
    console.log('分页状态验证完成');
  },

  // 获取用户收藏状态
  async fetchCollectionStatus(): Promise<Set<string>> {
    // 如果用户未登录，直接返回空集合
    if (!this.data.uid || this.data.uid === 'guest') {
      console.log('用户未登录，返回空收藏集合');
      return new Set<string>();
    }
    
    try {
      console.log('=== 获取用户收藏状态 ===');
      const res = await api.getCollectionList({ uid: this.data.uid, pageIndex: 1, pageSize: 20 });
      console.log('收藏列表接口返回:', res);
      
      let collectedIds: Set<string>;
      
      if (res && Array.isArray(res.data)) {
        // 创建收藏ID集合，用于快速查找
        const collectedItems = res.data.map((item: any) => {
          const id = item.id || item.inspiration_id;
          console.log('收藏项:', { item, extracted_id: id });
          return id;
        }).filter(id => id); // 过滤掉空值
        
        collectedIds = new Set(collectedItems);
        console.log('收藏列表中的所有ID:', collectedItems);
        console.log('已收藏的ID集合:', collectedIds);
      } else {
        // 如果接口返回异常，创建空集合
        collectedIds = new Set();
        console.log('接口返回异常，创建空收藏集合');
        console.log('接口返回类型:', typeof res, res);
      }
      
      // 将收藏ID集合保存到data中，供后续使用
      this.setData({
        collectedIds: collectedIds
      });
      
      console.log('保存到data的collectedIds类型:', typeof collectedIds, collectedIds instanceof Set);
      console.log('保存到data的collectedIds内容:', collectedIds);
      
      return collectedIds;
    } catch (error) {
      console.error('获取收藏状态失败:', error);
      // 发生错误时，创建空集合
      const emptySet = new Set<string>();
      this.setData({
        collectedIds: emptySet
      });
      return emptySet;
    }
  },

  // 转换API数据为feedList格式，并应用收藏状态
  transformApiDataWithCollectionStatus(apiData: any[]): IFeedItem[] {
    console.log('=== 转换API数据并应用收藏状态 ===');
    console.log('原始API数据:', apiData);
    console.log('当前收藏ID集合:', this.data.collectedIds);
    console.log('collectedIds类型:', typeof this.data.collectedIds, this.data.collectedIds instanceof Set);
    
    // 确保collectedIds是Set类型
    let collectedIds: Set<string>;
    if (this.data.collectedIds instanceof Set) {
      collectedIds = this.data.collectedIds;
    } else {
      console.warn('collectedIds不是Set类型，创建空集合');
      collectedIds = new Set();
    }
    
    // 如果用户未登录，所有内容都标记为未收藏
    if (!this.data.uid || this.data.uid === 'guest') {
      console.log('用户未登录，所有内容标记为未收藏');
      collectedIds = new Set();
    }
    
    console.log('用于对比的收藏ID集合:', collectedIds);
    console.log('收藏ID集合内容:', Array.from(collectedIds));
    
    const transformedData = apiData.map((item, index) => {
      const itemId = item.id || `${index + 1}`;
      const isCollected = collectedIds.has(itemId);
      
      console.log(`=== 对比第${index + 1}项 ===`);
      console.log('灵感内容ID:', itemId);
      console.log('是否在收藏集合中:', isCollected);
      console.log('收藏集合中的所有ID:', Array.from(collectedIds));
      
      const transformedItem = {
        id: itemId,
        uid: item.uid || item.author_id || '290',
        avatar: item.icon || '../../assets/image/1.png',
        username: item.username || item.author || '用户',
        image: item.image_url || '../../assets/image/1.png',
        title: item.ai_title || item.title || item.content || '灵感内容',
        ai_title: item.ai_title,
        likes: item.collect_count || item.likes || '0',
        comments: item.comment_count || item.comments || '0',
        liked: item.is_liked || item.liked || false,
        collected: isCollected, // 直接使用收藏ID集合判断
        collection: item.collect_count !== undefined ? item.collect_count : (item.collection || 0),
        height: item.height || 278
      };
      
      console.log(`转换第${index + 1}项结果:`, {
        原始数据: item,
        转换后: transformedItem,
        item_id: itemId,
        is_collected: isCollected,
        collect_count: item.collect_count,
        collection: transformedItem.collection,
        collected: transformedItem.collected
      });
      
      return transformedItem;
    });
    
    console.log('=== 所有数据转换完成 ===');
    console.log('转换后的数据（包含收藏状态）:', transformedData);
    console.log('收藏状态统计:', {
      总数量: transformedData.length,
      已收藏: transformedData.filter(item => item.collected).length,
      未收藏: transformedData.filter(item => !item.collected).length
    });
    
    return transformedData;
  },

  distributeData(): void {
    console.log('=== 分配数据到左右列 ===');
    console.log('feedList数据:', this.data.feedList);
    
    const left: IFeedItem[] = [];
    const right: IFeedItem[] = [];
    let leftHeight = 0;
    let rightHeight = 0;
    
    this.data.feedList.forEach((item: IFeedItem) => {
      const itemHeight = item.height || 278;
      
      if (leftHeight <= rightHeight) {
        left.push(item);
        leftHeight += itemHeight;
      } else {
        right.push(item);
        rightHeight += itemHeight;
      }
    });

    console.log('左列数据:', left);
    console.log('右列数据:', right);
    console.log('左列收藏数据:', left.map(item => ({ id: item.id, collection: item.collection, collected: item.collected })));
    console.log('右列收藏数据:', right.map(item => ({ id: item.id, collection: item.collection, collected: item.collected })));

    this.setData({
      leftColumnData: left,
      rightColumnData: right
    });
    
    console.log('=== 数据分配完成 ===');
    console.log('左列数据收藏状态:', left.map(item => ({ id: item.id, collected: item.collected, collection: item.collection })));
    console.log('右列数据收藏状态:', right.map(item => ({ id: item.id, collected: item.collected, collection: item.collection })));
    
    // 收藏状态已经在数据转换时应用，无需再次获取
  },

  // 新增：图片加载完成回调
  onImageLoad(_e: any): void {
    // 可以在这里更新对应item的高度
  },

  // 点击卡片跳转到详情页
  onCardClick(e: any): void {
    const { id, column } = e.currentTarget.dataset;
    console.log('点击卡片:', id, column);
    
    // 从对应的数据列中找到点击的项目
    const key = `${column}ColumnData` as 'leftColumnData' | 'rightColumnData';
    const columnData = (this.data as any)[key] as IFeedItem[];
    const clickedItem = columnData.find(item => item.id === id);
    
    if (clickedItem) {
      console.log('找到点击的项目:', clickedItem);
      
      // 使用真实的数据参数
      const params = {
        uid: clickedItem.uid,
        id: clickedItem.id,
        author_id: clickedItem.username
      };
      
      console.log('使用真实参数:', params);
      console.log('跳转URL:', `/pages/inspection/detail/detail?id=${params.id}&uid=${params.uid}&author_id=${params.author_id}`);
      
      wx.navigateTo({
        url: `/pages/inspection/detail/detail?id=${params.id}&uid=${params.uid}&author_id=${params.author_id}`
      });
    } else {
      console.error('未找到对应的数据项');
      wx.showToast({
        title: '数据错误',
        icon: 'error'
      });
    }
  },

  // 点击头像跳转到用户profile页面
  onAvatarClick(e: any): void {
    const { uid, username } = e.currentTarget.dataset;
    console.log('点击头像:', { uid, username });
    
    if (uid) {
      console.log('跳转到用户profile页面:', uid);
      wx.navigateTo({
        url: `/pages/inspection/profile/profile?uid=${uid}&username=${username || ''}`
      });
    } else {
      console.error('用户uid不存在');
      wx.showToast({
        title: '用户信息不完整',
        icon: 'error'
      });
    }
  },

  // 修改：收藏/取消收藏方法
  async onCollectionClick(e: any): Promise<void> {
      const { id, column } = e.currentTarget.dataset;
      const key = `${column}ColumnData` as 'leftColumnData' | 'rightColumnData';
      
      // 找到对应的数据项
      const columnData = ([...(this.data as any)[key]] as IFeedItem[]);
      const index = columnData.findIndex(item => item.id === id);
      
      if (index !== -1) {
        const item = columnData[index];
        const isCollected = item.collected || false;
        
        if (isCollected) {
          // 已收藏 -> 直接取消收藏
          await this.toggleCollection(item, key, index, 'cancel');
        } else {
          // 未收藏 -> 显示标签选择action sheet
          this.setData({
            currentCollectingItem: { item, key, index },
            showTagActionSheet: true
          });
          // 获取标签列表
          await this.fetchAvailableTags();
        }
      }
    },

    // 显示文件夹选择action-sheet
    async showFolderSelection(item: any, key: string, index: number): Promise<void> {
      try {
        // 获取文件夹列表
        const res = await api.getDirFileList({
          uid: this.data.uid,
          dir_id: ""
        });
        
        console.log('文件夹列表接口返回:', res);
        
        if (res && (res as any).status === 'success') {
          const directories = (res as any).directories || [];
          
          if (directories.length === 0) {
            wx.showToast({
              title: '暂无可用文件夹',
              icon: 'none'
            });
            return;
          }
          
          // 构建action-sheet选项
          const itemList = directories.map((dir: any) => dir.dir_name);
          
          wx.showActionSheet({
            itemList,
            itemColor: '#333333',
            success: async (actionRes) => {
              const selectedDir = directories[actionRes.tapIndex];
              console.log('用户选择的文件夹:', selectedDir);
              
              // 先同步文档到知识库
              await this.synchronizeDocToKnowledge(item, selectedDir);
              
              // 然后调用收藏接口
              await this.toggleCollection(item, key, index, 'collect');
            },
            fail: () => {
              console.log('用户取消选择文件夹');
            }
          });
        } else {
          wx.showToast({
            title: '获取文件夹列表失败',
            icon: 'error'
          });
        }
      } catch (error) {
        console.error('获取文件夹列表失败:', error);
        wx.showToast({
          title: '网络错误，请重试',
          icon: 'error'
        });
      }
    },

    // 同步文档到知识库
    async synchronizeDocToKnowledge(item: any, selectedDir: any): Promise<void> {
      try {
        console.log('=== 同步文档到知识库 ===');
        console.log('文档信息:', item);
        console.log('目标文件夹:', selectedDir);
        
        // 构建同步参数，将内容的详细信息全部传入
        const syncParams = {
          uid: this.data.uid,
          dir_id: selectedDir.dir_id,
          dir_name: selectedDir.dir_name,
          // 传入内容的详细信息
          content_id: item.id,
          title: item.title,
          ai_title: item.ai_title,
          content: item.content || '',
          author: item.username,
          publish_time: new Date().toISOString(),
          // 其他可能需要的字段
          ...item
        };
        
        console.log('同步参数:', syncParams);
        
        const res = await api.synchronizeDocToKnowledge(syncParams);
        console.log('同步接口返回:', res);
        
        if (res && (res as any).status === 'success') {
          console.log('文档同步成功');
        } else {
          console.warn('文档同步失败:', (res as any)?.message);
        }
      } catch (error) {
        console.error('同步文档到知识库失败:', error);
        // 这里不显示错误提示，因为同步失败不应该影响收藏操作
      }
    },

    // 执行收藏/取消收藏操作
    async toggleCollection(item: any, key: string, index: number, action: string, tags?: string[]): Promise<void> {
      try {
        console.log('=== 调用收藏接口 ===');
        console.log('请求参数:', { 
          id: item.id,
          action,
          uid: this.data.uid, 
          tags: tags || []
        });
        
        // 调用toggleCollection接口，使用新的传参格式
        const res = await api.toggleCollection({
          id: item.id,
          action,
          uid: this.data.uid,
          tags: tags || []
        });
        
        console.log('收藏接口返回:', res);
        
        // 使用类型断言处理接口返回的数据结构
        const resData = res as any;
        
        if (resData.status === 'success') {
          // 更新本地状态
          const newCollected = action === 'collect';
          const newCollection = newCollected ? 
            (item.collection || parseInt(item.likes) || 0) + 1 : 
            Math.max(0, (item.collection || parseInt(item.likes) || 0) - 1);
          
          const columnData = ([...(this.data as any)[key]] as IFeedItem[]);
          columnData[index] = {
            ...item,
            collected: newCollected,
            collection: newCollection
          };
          
          // 更新数据
          const updateData: any = {
            showToast: newCollected
          };
          updateData[key] = columnData;
          this.setData(updateData);
          
          // 如果是收藏操作，2秒后自动隐藏提示
          if (newCollected) {
            setTimeout(() => {
              this.setData({ showToast: false });
            }, 2000);
          }
        } else {
          if (action === 'collect') {
            // 失败时隐藏自定义 toast
            this.setData({ showToast: false });
          }
          wx.showToast({
            title: resData.message || '操作失败',
            icon: 'error'
          });
        }
      } catch (error: any) {
        console.error('收藏操作失败:', error);
        if (action === 'collect') {
          this.setData({ showToast: false });
        }
        wx.showToast({
          title: '网络错误，请重试',
          icon: 'error'
        });
      }
    },
    
    // 删除不再使用的方法
    
    // 空操作，防止事件冒泡
    noop(): void {
      // 空函数，用于阻止事件冒泡
    },
    
    // 隐藏提示框
    hideToast(): void {
      this.setData({ showToast: false });
    },

    navigateToPublish() {
      wx.navigateTo({
          url: '/pages/inspection/publish/publish'
      });
  },

  // 搜索输入事件
  onSearchInput(e: any) {
    this.setData({
      searchText: e.detail.value
    });
  },

  // 搜索按钮点击事件
  async onSearchClick() {
    if (!this.data.searchText.trim()) {
      wx.showToast({
        title: '请输入搜索内容',
        icon: 'none'
      });
      return;
    }

    wx.showLoading({
      title: '搜索中...',
      mask: true
    });

    try {
      // 确保有有效的uid，如果用户未登录则使用默认值
      let uid = this.data.uid;
      if (!uid || uid === 'guest') {
        uid = 'guest'; // 使用默认的游客uid
        console.log('用户未登录，使用默认uid进行搜索:', uid);
      }
      
      // 使用inspirationSearch接口搜索灵感内容
      const searchData = {
        uid: uid,
        search_text: this.data.searchText.trim(),
        page_index: 1,
        page_size: this.data.pageSize
      };

      console.log('=== 调用灵感搜索接口 ===');
      console.log('搜索参数:', searchData);
      console.log('当前用户uid:', this.data.uid);
      console.log('搜索使用的uid:', uid);
      console.log('搜索文本:', this.data.searchText.trim());
      console.log('分页参数:', { page_index: 1, page_size: this.data.pageSize });

      const result = await api.inspirationSearch(searchData);
      
      wx.hideLoading();
      
      if (result && result.data) {
        console.log('搜索结果:', result.data);
        
        // 处理搜索结果数据
        if (Array.isArray(result.data) && result.data.length > 0) {
          // 处理图片URL
          result.data.forEach((item: any) => {
            item.image_url = 'https://www.aispire.info' + item.image_url.replace(/.*?(?=\/inspiration_images)/, '').replace(/.*?(?=\/private_knowledge)/, '');
            item.icon = item.icon.replace(/.*?(?=\/user_portrait)/, '');
          });
          
          // 转换搜索结果格式并应用收藏状态
          const searchResults = this.transformApiDataWithCollectionStatus(result.data);
          
          // 更新页面数据，显示搜索结果
          this.setData({
            feedList: searchResults,
            pageIndex: 1,
            hasMore: result.data.length === this.data.pageSize, // 如果返回的数据量等于页大小，说明可能还有更多
            searchText: this.data.searchText.trim(), // 保持搜索文本
            isSearchMode: true // 设置为搜索模式
          });
          
          // 重新分配数据到左右列
          this.distributeData();
          
          console.log('搜索完成，结果数量:', searchResults.length);
        //   wx.showToast({
        //     title: `找到${searchResults.length}条相关内容`,
        //     icon: 'success'
        //   });
        } else {
          // 没有搜索结果
          this.setData({
            feedList: [],
            leftColumnData: [],
            rightColumnData: [],
            pageIndex: 1,
            hasMore: false
          });
          
          wx.showToast({
            title: '没有找到相关内容',
            icon: 'none'
          });
        }
        
      } else {
        wx.showToast({
          title: '搜索失败',
          icon: 'error'
        });
      }
      
    } catch (error) {
      wx.hideLoading();
      console.error('搜索失败:', error);
      wx.showToast({
        title: '搜索失败，请重试',
        icon: 'error'
      });
    }
  },

  // 加载更多搜索结果
  async loadMoreSearchResults(nextPageIndex: number) {
    try {
      console.log('=== 加载更多搜索结果 ===');
      console.log('页码:', nextPageIndex);
      
      // 确保有有效的uid
      let uid = this.data.uid;
      if (!uid || uid === 'guest') {
        uid = 'guest';
      }
      
      // 调用搜索接口获取下一页数据
      const searchData = {
        uid: uid,
        search_text: this.data.searchText.trim(),
        page_index: nextPageIndex,
        page_size: this.data.pageSize
      };

      console.log('搜索更多参数:', searchData);

      const result = await api.inspirationSearch(searchData);
      
      if (result && result.data) {
        console.log('更多搜索结果:', result.data);
        
        if (Array.isArray(result.data) && result.data.length > 0) {
          // 处理图片URL
          result.data.forEach((item: any) => {
            item.image_url = 'https://www.aispire.info' + item.image_url.replace(/.*?(?=\/inspiration_images)/, '').replace(/.*?(?=\/private_knowledge)/, '');
            item.icon = item.icon.replace(/.*?(?=\/user_portrait)/, '');
          });
          
          // 转换搜索结果格式并应用收藏状态
          const newSearchResults = this.transformApiDataWithCollectionStatus(result.data);
          
          // 合并到现有搜索结果中
          const allSearchResults = [...this.data.feedList, ...newSearchResults];
          
          // 更新页面数据
          this.setData({
            feedList: allSearchResults,
            pageIndex: nextPageIndex,
            hasMore: result.data.length === this.data.pageSize, // 如果返回的数据量等于页大小，说明可能还有更多
            isLoadingMore: false
          });
          
          // 重新分配数据到左右列
          this.distributeData();
          
          console.log('加载更多搜索完成，总结果数量:', allSearchResults.length);
        //   wx.showToast({
        //     title: `已加载${allSearchResults.length}条搜索结果`,
        //     icon: 'success'
        //   });
        } else {
          // 没有更多搜索结果
          this.setData({
            hasMore: false,
            isLoadingMore: false
          });
          
          wx.showToast({
            title: '没有更多搜索结果了',
            icon: 'none'
          });
        }
      } else {
        this.setData({
          hasMore: false,
          isLoadingMore: false
        });
        
        wx.showToast({
          title: '加载更多失败',
          icon: 'error'
        });
      }
      
    } catch (error) {
      console.error('加载更多搜索结果失败:', error);
      this.setData({ isLoadingMore: false });
      
      wx.showToast({
        title: '加载失败，请重试',
        icon: 'error'
      });
    }
  },

  // 清除搜索，返回推荐内容
  onClearSearch() {
    console.log('=== 清除搜索，返回推荐内容 ===');
    
    // 清空搜索文本
    this.setData({
      searchText: '',
      pageIndex: 1,
      hasMore: true,
      isSearchMode: false // 退出搜索模式
    });
    
    // 重新获取推荐内容
    this.fetchInspirationData(false);
    
    wx.showToast({
      title: '已返回推荐内容',
      icon: 'success'
    });
  },

  /**
   * 监听用户下拉刷新事件
   */
  onPullDownRefresh(){
    console.log('=== 下拉刷新 ===');
    console.log('刷新前状态:', {
      当前数据量: this.data.feedList.length,
      当前页码: this.data.pageIndex,
      是否还有更多: this.data.hasMore
    });
    
    // 重置分页状态并重新获取数据
    this.setData({
      pageIndex: 1,        // 重置为第1页
      hasMore: true,       // 重置为有更多数据
      feedList: [],        // 清空现有数据，避免显示旧数据
      leftColumnData: [],  // 清空左列数据
      rightColumnData: []  // 清空右列数据
    });
    
    // 显示刷新提示
    wx.showToast({
      title: '正在刷新...',
      icon: 'loading',
      duration: 1000
    });
    
    // 重新获取数据
    if (this.data.isSearchMode) {
      // 搜索模式下，重新搜索
      this.onSearchClick();
    } else {
      // 推荐模式下，重新获取推荐内容
      this.fetchInspirationData(false).then(() => {
        console.log('下拉刷新完成');
        console.log('刷新后状态:', {
          当前数据量: this.data.feedList.length,
          当前页码: this.data.pageIndex,
          是否还有更多: this.data.hasMore
        });
        
        // 验证分页状态
        this.validatePaginationState();
        
        // 显示刷新成功提示
        wx.showToast({
          title: `已刷新${this.data.feedList.length}条数据`,
          icon: 'success',
          duration: 1500
        });
        
        wx.stopPullDownRefresh();
      }).catch((error) => {
        console.error('下拉刷新失败:', error);
        
        // 显示刷新失败提示
        wx.showToast({
          title: '刷新失败，请重试',
          icon: 'error',
          duration: 2000
        });
        
        wx.stopPullDownRefresh();
      });
    }
  },
  
  /**
   * 监听用户触底事件，实现加载更多
   */
  onReachBottom() {
    console.log('=== 触底加载更多 ===');
    console.log('触底时状态:', {
      当前数据量: this.data.feedList.length,
      当前页码: this.data.pageIndex,
      是否还有更多: this.data.hasMore,
      是否正在加载: this.data.isLoadingMore,
      是否正在刷新: this.data.loading
    });
    
    // 检查是否还有更多数据且不在加载中
    if (this.data.hasMore && !this.data.isLoadingMore && !this.data.loading) {
      const nextPageIndex = this.data.pageIndex + 1;
      console.log('开始加载更多数据...');
      console.log('即将加载第', nextPageIndex, '页数据');
      console.log('当前页码:', this.data.pageIndex, '下一页页码:', nextPageIndex);
      console.log('分页参数:', {
        uid: this.data.uid,
        page_index: nextPageIndex,
        page_size: this.data.pageSize
      });
      
      // 显示加载提示
      wx.showToast({
        title: '正在加载更多...',
        icon: 'loading',
        duration: 1000
      });
      
      // 调用加载更多
      if (this.data.isSearchMode) {
        // 搜索模式下，调用搜索接口加载更多
        this.loadMoreSearchResults(nextPageIndex);
      } else {
        // 推荐模式下，调用推荐接口加载更多
        this.fetchInspirationData(true).then(() => {
          console.log('加载更多完成');
          console.log('加载后状态:', {
            当前数据量: this.data.feedList.length,
            当前页码: this.data.pageIndex,
            是否还有更多: this.data.hasMore
          });
          
          // 验证分页状态
          this.validatePaginationState();
        }).catch((error) => {
          console.error('加载更多失败:', error);
          
          // 显示加载失败提示
          wx.showToast({
            title: '加载失败，请重试',
            icon: 'error',
            duration: 2000
          });
        });
      }
    } else {
      console.log('无需加载更多数据:', {
        hasMore: this.data.hasMore,
        isLoadingMore: this.data.isLoadingMore,
        loading: this.data.loading
      });
      
      if (!this.data.hasMore) {
        // 提示用户已经到底了
        wx.showToast({
          title: '已经到底了',
          icon: 'none',
          duration: 2000
        });
      } else if (this.data.isLoadingMore || this.data.loading) {
        // 提示用户正在加载中
        wx.showToast({
          title: '正在加载中，请稍候...',
          icon: 'none',
          duration: 1000
        });
      }
    }
  },

  // ========== 标签管理相关方法 ==========
  
  // 获取可用标签列表
  async fetchAvailableTags() {
    try {
      console.log('=== 获取标签列表 ===');
      const userInfo = common.getAppUserInfo();
      const uid = userInfo?.uid || userInfo?.userId;
      
      if (!uid) {
        console.error('用户uid不存在，无法获取标签列表');
        return;
      }
      
      const res = await api.getAvailableTags({ uid });
      console.log('标签列表接口返回:', res);
      
      if (res && (res as any).tags && Array.isArray((res as any).tags)) {
        // 将字符串数组转换为对象数组，每个对象包含name和selected属性
        const tagsWithSelection = (res as any).tags.map((tagName: string) => ({
          name: tagName,
          selected: false
        }));
        
        this.setData({
          availableTags: tagsWithSelection
        });
        console.log('标签列表设置完成:', tagsWithSelection);
      } else {
        console.log('标签列表为空');
        this.setData({
          availableTags: []
        });
      }
    } catch (error) {
      console.error('获取标签列表失败:', error);
      this.setData({
        availableTags: []
      });
    }
  },
  
  // 显示标签Action Sheet
  showTagActionSheet() {
    this.setData({
      showTagActionSheet: true
    });
  },
  
  // 隐藏标签Action Sheet
  hideTagActionSheet() {
    // 重置所有标签的选中状态
    const availableTags = this.data.availableTags.map(tag => ({
      ...tag,
      selected: false
    }));
    
    this.setData({
      showTagActionSheet: false,
      availableTags: availableTags,
      selectedTags: [],
      currentCollectingItem: null
    });
  },
  
  // 标签点击事件（切换选中状态）
  onTagClick(e: any) {
    const tagName = e.currentTarget.dataset.tag;
    const tagIndex = e.currentTarget.dataset.index;
    console.log('点击标签:', tagName, '索引:', tagIndex);
    
    // 更新availableTags中对应标签的selected状态
    const availableTags = [...this.data.availableTags];
    const tag = availableTags[tagIndex];
    
    if (tag) {
      tag.selected = !tag.selected;
      console.log('标签选中状态切换:', tag.name, '->', tag.selected);
      
      // 同时更新selectedTags数组
      const selectedTags = availableTags
        .filter(t => t.selected)
        .map(t => t.name);
      
      this.setData({
        availableTags: availableTags,
        selectedTags: selectedTags
      });
      
      console.log('更新后的availableTags:', availableTags);
      console.log('更新后的selectedTags:', selectedTags);
    }
  },
  
  // 显示标签管理弹窗
  showTagManager() {
    this.setData({
      showTagModal: true
    });
  },
  
  // 隐藏标签管理弹窗
  hideTagManager() {
    this.setData({
      showTagModal: false,
      newTagName: ''
    });
  },
  
  // 标签名称输入
  onTagNameInput(e: any) {
    this.setData({
      newTagName: e.detail.value
    });
  },
  
  // 创建新标签
  async onCreateTag() {
    const tagName = this.data.newTagName.trim();
    
    if (!tagName) {
      wx.showToast({
        title: '请输入标签名称',
        icon: 'none'
      });
      return;
    }
    
    // 检查标签是否已存在
    if (this.data.availableTags.includes(tagName)) {
      wx.showToast({
        title: '标签已存在',
        icon: 'none'
      });
      return;
    }
    
    try {
      console.log('=== 创建新标签 ===');
      const userInfo = common.getAppUserInfo();
      const uid = userInfo?.uid || userInfo?.userId;
      
      if (!uid) {
        wx.showToast({
          title: '用户信息错误',
          icon: 'error'
        });
        return;
      }
      
      const res = await api.createTag({ action: 'add', uid: parseInt(uid), tags: tagName });
      console.log('创建标签接口返回:', res);
      
      if (res && (res as any).status === 'success') {
        // 创建成功，更新本地标签列表
        const newTag = { name: tagName, selected: false };
        const newTags = [...this.data.availableTags, newTag];
        this.setData({
          availableTags: newTags,
          newTagName: '',
          showTagModal: false // 关闭弹窗
        });
        
        wx.showToast({
          title: '标签创建成功',
          icon: 'success'
        });
      } else {
        wx.showToast({
          title: (res as any)?.message || '创建失败',
          icon: 'error'
        });
      }
    } catch (error) {
      console.error('创建标签失败:', error);
      wx.showToast({
        title: '网络错误，请重试',
        icon: 'error'
      });
    }
  },
  
  // 确认收藏（带标签）
  async confirmCollectionWithTags() {
    const { currentCollectingItem, selectedTags } = this.data;
    if (!currentCollectingItem) {
      wx.showToast({
        title: '收藏项目信息错误',
        icon: 'error'
      });
      return;
    }
    
    const { item, key, index } = currentCollectingItem;
    
    // 隐藏action sheet并显示收藏提示
    this.setData({
      showTagActionSheet: false,
      showToast: true
    });
    
    // 执行收藏操作，传入选中的标签
    await this.toggleCollection(item, key, index, 'collect', selectedTags);
    
    // 清空当前收藏项目
    this.setData({
      currentCollectingItem: null,
      selectedTags: []
    });
  },

  // 直接收藏（不选择标签）
  async confirmCollectionWithoutTags() {
    const { currentCollectingItem } = this.data;
    if (!currentCollectingItem) {
      wx.showToast({
        title: '收藏项目信息错误',
        icon: 'error'
      });
      return;
    }
    
    const { item, key, index } = currentCollectingItem;
    
    // 隐藏action sheet并显示收藏提示
    this.setData({
      showTagActionSheet: false,
      showToast: true
    });
    
    // 执行收藏操作，不传标签参数
    await this.toggleCollection(item, key, index, 'collect', []);
    
    // 清空当前收藏项目
    this.setData({
      currentCollectingItem: null,
      selectedTags: []
    });
  }

});